home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Chans / qmgr-load / ryresponder.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  8.4 KB  |  411 lines

  1. /* ryresponder.c - generic idempotent responder */
  2.  
  3. # ifndef lint
  4. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Chans/qmgr-load/RCS/ryresponder.c,v 6.0 1991/12/18 20:11:26 jpo Rel $";
  5. # endif
  6.  
  7. /*
  8.  * $Header: /xtel/pp/pp-beta/Chans/qmgr-load/RCS/ryresponder.c,v 6.0 1991/12/18 20:11:26 jpo Rel $
  9.  *
  10.  * $Log: ryresponder.c,v $
  11.  * Revision 6.0  1991/12/18  20:11:26  jpo
  12.  * Release 6.0
  13.  *
  14.  */
  15.  
  16.  
  17.  
  18. /*
  19.  *                                NOTICE
  20.  *
  21.  *    Acquisition, use, and distribution of this module and related
  22.  *    materials are subject to the restrictions of a license agreement.
  23.  *    Consult the Preface in the User's Manual for the full terms of
  24.  *    this agreement.
  25.  *
  26.  */
  27.  
  28.  
  29. #include "Qmgr-ops.h"                   /* operation definitions */
  30. #include "util.h"
  31. #include <varargs.h>
  32. #include "ryresponder.h"
  33. #include <isode/tsap.h>         /* for listening */
  34.  
  35. /*     DATA */
  36.  
  37. static char     *myname = "ryresponder";
  38. static jmp_buf  toplevel;
  39. static IFP      startfnx;
  40. static IFP      stopfnx;
  41. static int    ros_init (),
  42.         ros_work (),
  43.         ros_indication (),
  44.         ros_lose ();
  45. extern int      errno;
  46.  
  47.  
  48.  
  49. /*     RESPONDER */
  50.  
  51. /* ARGSUSED */
  52. int     ryresponder (argc, argv, host, myservice, dispatches, ops, start, stop)
  53. int     argc;
  54. char  **argv,
  55.        *host,
  56.        *myservice;
  57. struct server_dispatch *dispatches;
  58. struct RyOperation *ops;
  59. IFP     start,
  60.     stop;
  61. {
  62.     register struct server_dispatch   *ds;
  63.     AEI     aei = NULLAEI;
  64.     struct TSAPdisconnect   tds;
  65.     struct TSAPdisconnect  *td = &tds;
  66.     struct RoSAPindication  rois;
  67.     register struct RoSAPindication *roi = &rois;
  68.     register struct RoSAPpreject   *rop = &roi -> roi_preject;
  69.  
  70.     if ((myname = rindex (argv[0], '/')) != NULLCP)
  71.     myname++;
  72.     if (myname == NULL || *myname == NULL)
  73.     myname = argv[0];
  74.  
  75.     PP_TRACE(("starting"));
  76.  
  77.     for (ds = dispatches; ds -> ds_name; ds++)
  78.     if (RyDispatch (NOTOK, ops, ds -> ds_operation, ds -> ds_vector, roi)
  79.         == NOTOK)
  80.         ros_adios (rop, ds -> ds_name);
  81.  
  82.     startfnx = start;
  83.     stopfnx = stop;
  84.  
  85.     if (isodeserver (argc, argv, aei, ros_init, ros_work, ros_lose, td)
  86.         == NOTOK) {
  87.     if (td -> td_cc > 0)
  88.         adios (NULLCP, "isodeserver: [%s] %*.*s",
  89.             TErrString (td -> td_reason),
  90.             td -> td_cc, td -> td_cc, td -> td_data);
  91.     else
  92.         adios (NULLCP, "isodeserver: [%s]",
  93.             TErrString (td -> td_reason));
  94.     }
  95.  
  96.     return 0;
  97. }
  98.  
  99. /*   */
  100.  
  101. static int  ros_init (vecp, vec)
  102. int     vecp;
  103. char  **vec;
  104. {
  105.     int     reply,
  106.         result,
  107.         sd;
  108.     struct AcSAPstart   acss;
  109.     register struct AcSAPstart *acs = &acss;
  110.     struct AcSAPindication  acis;
  111.     register struct AcSAPindication *aci = &acis;
  112.     register struct AcSAPabort   *aca = &aci -> aci_abort;
  113.     register struct PSAPstart *ps = &acs -> acs_start;
  114.     struct RoSAPindication  rois;
  115.     register struct RoSAPindication *roi = &rois;
  116.     register struct RoSAPpreject   *rop = &roi -> roi_preject;
  117.  
  118.     if (AcInit (vecp, vec, acs, aci) == NOTOK) {
  119.     acs_advise (aca, "initialization fails");
  120.     return NOTOK;
  121.     }
  122.     PP_LOG( LLOG_NOTICE,
  123.        ("A-ASSOCIATE.INDICATION: <%d, %s, %s, %s, %d>",
  124.         acs -> acs_sd, sprintoid (acs -> acs_context),
  125.         sprintaei (&acs -> acs_callingtitle),
  126.         sprintaei (&acs -> acs_calledtitle), acs -> acs_ninfo));
  127.  
  128.     sd = acs -> acs_sd;
  129.  
  130.     for (vec++; *vec; vec++)
  131.     PP_LOG( LLOG_EXCEPTIONS, ("unknown argument \"%s\"", *vec));
  132.  
  133.     reply = startfnx ? (*startfnx) (sd, acs) : ACS_ACCEPT;
  134.  
  135.     result = AcAssocResponse (sd, reply, 
  136.         reply != ACS_ACCEPT ? ACS_USER_NOREASON : ACS_USER_NULL,
  137.         NULLOID, NULLAEI, NULLPA, NULLPC, ps -> ps_defctxresult,
  138.         ps -> ps_prequirements, ps -> ps_srequirements, SERIAL_NONE,
  139.         ps -> ps_settings, &ps -> ps_connect, NULLPEP, 0, aci);
  140.  
  141.     ACSFREE (acs);
  142.  
  143.     if (result == NOTOK) {
  144.     acs_advise (aca, "A-ASSOCIATE.RESPONSE");
  145.     return NOTOK;
  146.     }
  147.     if (reply != ACS_ACCEPT)
  148.     return NOTOK;
  149.  
  150.     if (RoSetService (sd, RoPService, roi) == NOTOK)
  151.     ros_adios (rop, "set RO/PS fails");
  152.  
  153.     return sd;
  154. }
  155.  
  156. /*   */
  157.  
  158. static int  ros_work (fd)
  159. int     fd;
  160. {
  161.     int     result;
  162.     caddr_t out;
  163.     struct AcSAPindication  acis;
  164.     struct RoSAPindication  rois;
  165.     register struct RoSAPindication *roi = &rois;
  166.     register struct RoSAPpreject   *rop = &roi -> roi_preject;
  167.  
  168.     switch (setjmp (toplevel)) {
  169.     case OK: 
  170.         break;
  171.  
  172.     default: 
  173.         if (stopfnx)
  174.         (*stopfnx) (fd, (struct AcSAPfinish *) 0);
  175.     case DONE:
  176.         (void) AcUAbortRequest (fd, NULLPEP, 0, &acis);
  177.         (void) RyLose (fd, roi);
  178.         return NOTOK;
  179.     }
  180.  
  181.     switch (result = RyWait (fd, NULLIP, &out, OK, roi)) {
  182.     case NOTOK: 
  183.         if (rop -> rop_reason == ROS_TIMER)
  184.         break;
  185.     case OK: 
  186.     case DONE: 
  187.         ros_indication (fd, roi);
  188.         break;
  189.  
  190.     default: 
  191.         adios (NULLCP, "unknown return from RoWaitRequest=%d", result);
  192.     }
  193.  
  194.     return OK;
  195. }
  196.  
  197. /*   */
  198.  
  199. static int ros_indication (sd, roi)
  200. int     sd;
  201. register struct RoSAPindication *roi;
  202. {
  203.     int     reply,
  204.         result;
  205.  
  206.     switch (roi -> roi_type) {
  207.     case ROI_INVOKE: 
  208.     case ROI_RESULT: 
  209.     case ROI_ERROR: 
  210.         adios (NULLCP, "unexpected indication type=%d", roi -> roi_type);
  211.         break;
  212.  
  213.     case ROI_UREJECT: 
  214.         {
  215.         register struct RoSAPureject   *rou = &roi -> roi_ureject;
  216.  
  217.         if (rou -> rou_noid)
  218.             PP_LOG( LLOG_NOTICE, 
  219.                ("RO-REJECT-U.INDICATION/%d: %s",
  220.                 sd, RoErrString (rou -> rou_reason)));
  221.         else
  222.             PP_LOG( LLOG_NOTICE,
  223.                ("RO-REJECT-U.INDICATION/%d: %s (id=%d)",
  224.                 sd, RoErrString (rou -> rou_reason),
  225.                 rou -> rou_id));
  226.         }
  227.         break;
  228.  
  229.     case ROI_PREJECT: 
  230.         {
  231.         register struct RoSAPpreject   *rop = &roi -> roi_preject;
  232.  
  233.         if (ROS_FATAL (rop -> rop_reason))
  234.             ros_adios (rop, "RO-REJECT-P.INDICATION");
  235.         ros_advise (rop, "RO-REJECT-P.INDICATION");
  236.         }
  237.         break;
  238.  
  239.     case ROI_FINISH: 
  240.         {
  241.         register struct AcSAPfinish *acf = &roi -> roi_finish;
  242.         struct AcSAPindication  acis;
  243.         register struct AcSAPabort *aca = &acis.aci_abort;
  244.  
  245.         PP_LOG( LLOG_NOTICE, 
  246.                ("A-RELEASE.INDICATION/%d: %d",
  247.             sd, acf -> acf_reason));
  248.  
  249.         reply = stopfnx ? (*stopfnx) (sd, acf) : ACS_ACCEPT;
  250.  
  251.         result = AcRelResponse (sd, reply, ACR_NORMAL, NULLPEP, 0,
  252.                 &acis);
  253.  
  254.         ACFFREE (acf);
  255.  
  256.         if (result == NOTOK)
  257.             acs_advise (aca, "A-RELEASE.RESPONSE");
  258.         else
  259.             if (reply != ACS_ACCEPT)
  260.             break;
  261.         longjmp (toplevel, DONE);
  262.         }
  263.     /* NOTREACHED */
  264.  
  265.     default: 
  266.         adios (NULLCP, "unknown indication type=%d", roi -> roi_type);
  267.     }
  268. }
  269.  
  270. /*   */
  271.  
  272. static int  ros_lose (td)
  273. struct TSAPdisconnect *td;
  274. {
  275.     if (td -> td_cc > 0)
  276.     PP_LOG( LLOG_NOTICE,
  277.            ("TNetAccept: [%s] %*.*s",
  278.         TErrString (td -> td_reason), td -> td_cc, td -> td_cc,
  279.         td -> td_data));
  280.     else
  281.         PP_LOG( LLOG_NOTICE,
  282.            ("TNetAccept: [%s]",TErrString (td -> td_reason)));
  283. }
  284.  
  285. /*     ERRORS */
  286.  
  287. void    ros_adios (rop, event)
  288. register struct RoSAPpreject *rop;
  289. char   *event;
  290. {
  291.     ros_advise (rop, event);
  292.  
  293.     longjmp (toplevel, NOTOK);
  294. }
  295.  
  296.  
  297. void    ros_advise (rop, event)
  298. register struct RoSAPpreject *rop;
  299. char   *event;
  300. {
  301.     char    buffer[BUFSIZ];
  302.  
  303.     if (rop -> rop_cc > 0)
  304.     (void) sprintf (buffer, "[%s] %*.*s", RoErrString (rop -> rop_reason),
  305.         rop -> rop_cc, rop -> rop_cc, rop -> rop_data);
  306.     else
  307.     (void) sprintf (buffer, "[%s]", RoErrString (rop -> rop_reason));
  308.  
  309.     PP_LOG( LLOG_NOTICE, ("%s: %s", event, buffer));
  310. }
  311.  
  312. /*   */
  313.  
  314. void    acs_advise (aca, event)
  315. register struct AcSAPabort *aca;
  316. char   *event;
  317. {
  318.     char    buffer[BUFSIZ];
  319.  
  320.     if (aca -> aca_cc > 0)
  321.     (void) sprintf (buffer, "[%s] %*.*s",
  322.         AcErrString (aca -> aca_reason),
  323.         aca -> aca_cc, aca -> aca_cc, aca -> aca_data);
  324.     else
  325.     (void) sprintf (buffer, "[%s]", AcErrString (aca -> aca_reason));
  326.  
  327.     PP_LOG( LLOG_NOTICE, 
  328.        ("%s: %s (source %d)", event, buffer,aca -> aca_source));
  329. }
  330.  
  331. /*   */
  332.  
  333. #ifndef lint
  334. void    adios (va_alist)
  335. va_dcl
  336. {
  337.     va_list ap;
  338.  
  339.     va_start (ap);
  340.  
  341.     _ll_log (pp_log_norm, LLOG_FATAL, ap);
  342.  
  343.     va_end (ap);
  344.  
  345.     _exit (1);
  346. }
  347. #else
  348. /* VARARGS */
  349.  
  350. void    adios (what, fmt)
  351. char   *what,
  352.        *fmt;
  353. {
  354.     adios (what, fmt);
  355. }
  356. #endif
  357.  
  358.  
  359. #ifndef lint
  360. void    advise (va_alist)
  361. va_dcl
  362. {
  363.     int     code;
  364.     va_list ap;
  365.  
  366.     va_start (ap);
  367.  
  368.     code = va_arg (ap, int);
  369.  
  370.     _ll_log (pp_log_norm, code, ap);
  371.  
  372.     va_end (ap);
  373. }
  374.  
  375.  
  376. #else
  377. /* VARARGS */
  378.  
  379. void    advise (what, code, fmt)
  380. char   *what,
  381.        *fmt;
  382. int     code;
  383. {
  384.     advise (what, code, fmt);
  385. }
  386. #endif
  387.  
  388.  
  389. /* VARARGS */
  390.  
  391. #ifndef lint
  392. void    ryr_advise (va_alist)
  393. va_dcl
  394. {
  395.     va_list ap;
  396.  
  397.     va_start (ap);
  398.  
  399.     _ll_log (pp_log_norm, LLOG_NOTICE, ap);
  400.  
  401.     va_end (ap);
  402. }
  403. #else
  404. void    ryr_advise (what, fmt)
  405. char   *what,
  406.        *fmt;
  407. {
  408.     ryr_advise (what, fmt);
  409. }
  410. #endif
  411.